package com.monolithiot.camera.help;


import com.monolithiot.camera.util.ByteUtils;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Base64;

/**
 * Create By TreeRoot
 * Create Time: 2024/02/06 03:26
 * Class Name: CameraDataHelp
 * Description:
 * 辅助类
 *
 * @author TreeRoot
 */
@SuppressWarnings("unused")
public class CameraDataHelp {
    private static final byte LEGITIMATE_BEGINNING_0 = 3;
    private static final byte LEGITIMATE_BEGINNING_1 = 0;
    private static final byte LEGITIMATE_BEGINNING_2 = 0;
    private static final byte LEGITIMATE_BEGINNING_3 = 0;


    // 将 BufferedImage 转换成 Base64 字符串
    public static String convertImageToBase64(BufferedImage image) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(image, "png", baos);
        byte[] imageBytes = baos.toByteArray();

        return Base64.getEncoder().encodeToString(imageBytes);
    }

    /**
     * 检查数据包是否非法
     * 检查数据包长度是否为64624
     * 检查数据包开始是否为03
     *
     * @param receivedData 接收到的数据
     */
    public static boolean checkDataPacketIsIllegal(byte[] receivedData) {
        if (receivedData.length != 64624) {
            return true;
        }
        return !(LEGITIMATE_BEGINNING_0 == receivedData[0]
                && LEGITIMATE_BEGINNING_1 == receivedData[1]
                && LEGITIMATE_BEGINNING_2 == receivedData[2]
                && LEGITIMATE_BEGINNING_3 == receivedData[3]);
    }

    /**
     * 组成256阶灰度的图片
     * 相机左边相机的图像数据
     * 开始地址4
     * 数据长度 320 * 200
     *
     * @return BufferedImage
     */
    public static BufferedImage createImage(int width, int height, byte[] cameraData) {
        if (width == 0) {
            width = 320;
        }
        if (height == 0) {
            height = 180;
        }
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
        WritableRaster raster = image.getRaster();
        raster.setDataElements(0, 0, 320, 180, cameraData);
        return image;
    }


    /**
     * 获取检查到到人数
     * 开始地址 64004
     * 数据长度 4
     * 使用for循环效率高 更消耗性能-  使用System.arraycopy效率低于for循环 更节省性能且基于底层的系统指令来实现
     *
     * @return 十六进制的 String
     */
    public static int getCheckPeopleNum(ByteBuffer receivedData) {
        byte[] bytes = new byte[4];
        System.arraycopy(receivedData.array(), 64004, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);
    }

    /**
     * 获取人头编号
     * 开始地址 64008 + 10 * i + 0
     * 数据长度 4
     *
     * @param receivedData 一包数据
     * @param i            重复i次，i等于检测到的总人数。用于表示每个人的数据长度为10个字节，最多是50个人，数据长度固定为500字节，不足50人的数据部分默认为0。
     * @return 十六进制的 String
     */
    public static int getHeadNums(ByteBuffer receivedData, int i) {
        byte[] bytes = new byte[4];
        System.arraycopy(receivedData.array(), 64008 + 12 * i, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);
    }

    /**
     * 人头x坐标
     * 开始地址 64008 + 10 * i + 4
     * 数据长度 2
     *
     * @return 十六进制的 String
     */
    public static int getHeadX(ByteBuffer receivedData, int i) {
        byte[] bytes = new byte[2];
        System.arraycopy(receivedData.array(), 64008 + 12 * i + 4, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);
    }

    /**
     * 人头y坐标
     * 开始地址 64008 + 10 * i + 6
     * 数据长度 2
     *
     * @return 十六进制的 String
     */
    public static int getHeadY(ByteBuffer receivedData, int i) {
        byte[] bytes = new byte[2];
        System.arraycopy(receivedData.array(), 64008 + 12 * i + 6, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);
    }

    /**
     * 获取身高
     * 开始地址 64008 + 10 * i + 8
     * 数据长度 1
     *
     * @return 十六进制的 String
     */
    public static int getHeight(ByteBuffer receivedData, int i) {
        byte[] bytes = new byte[1];
        System.arraycopy(receivedData.array(), 64008 + 12 * i + 8, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);
    }

    /**
     * 获取跟踪状态
     * 开始地址 64008 + 10 * i + 9
     * 数据长度 1
     *
     * @return 十六进制的 String
     */
    public static int getTrackStatus(ByteBuffer receivedData, int i) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64008 + 12 * i + 9, 1));

    }

    /**
     * 64008 + 12 * i + 10
     *
     * @param receivedData 一包数据
     * @param i           重复i次，i等于检测到的总人数。用于表示每个人的数据长度为10个字节，最多是50个人，数据长度固定为500字节，不足50人的数据部分默认为0。
     * @return 十六进制的 String
     */
    public static int getStayTime(ByteBuffer receivedData, int i) {
        byte[] bytes = new byte[2];
        System.arraycopy(receivedData.array(), 64008 + 12 * i + 10, bytes, 0, bytes.length);
        return ByteUtils.bytesToInt(bytes);

    }

    /**
     * CPU温度过高提示
     * 开始地址 64508
     * 数据长度 4
     *
     * @return 0：温度正常 1：温度过高
     */
    public static int getCpuTemperatureTip(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64508, 4));
    }

    /**
     * 最大检测区域左上角x坐标
     *
     * @return 十六进制的 String
     * 在地面的最大检测区域，人的脚在该区域内可以被统计
     * 开始地址 64512
     * 数据长度 4
     */
    public static int getMaxDetectionAreaLeftTopX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64512, 4));
    }

    /**
     * 最大检测区域左上角y坐标
     *
     * @return 十六进制的 String
     * 在地面的最大检测区域，人的脚在该区域内可以被统计
     * 开始地址 64516
     * 数据长度 4
     */
    public static int getMaxDetectionAreaLeftTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64516, 4));
    }

    /**
     * 最大检测区域右下角x坐标
     *
     * @return 十六进制的 String
     * 在地面的最大检测区域，人的脚在该区域内可以被统计
     * 开始地址 64520
     * 数据长度 4
     */
    public static int getMaxDetectionAreaRightBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64520, 4));
    }

    /**
     * 最大检测区域右下角y坐标
     *
     * @return 十六进制的 String
     * 在地面的最大检测区域，人的脚在该区域内可以被统计
     * <p>
     * 开始地址 64524
     * 数据长度 4
     */
    public static int getMaxDetectionAreaRightBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64524, 4));
    }

    /**
     * 最小检测区域宽度
     *
     * @return 十六进制的 String
     * 在地面的最小检测区域，人的脚在该区域内可以被统
     * 开始地址 64528
     * 数据长度 4
     */
    public static int getMinDetectionAreaWidth(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64528, 4));
    }

    /**
     * 最小检测区域高度
     *
     * @return 十六进制的 String
     * 在地面的最小检测区域，人的脚在该区域内可以被统计
     * 开始地址 64532
     * 数据长度 4
     */
    public static int getMinDetectionAreaHeight(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64532, 4));
    }

    /**
     * 当前检测区域左上角x坐标
     * <p>
     * 在地面的当前检测区域，人的脚在该区域内可以被统计
     * 开始地址 64536
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaLeftTopX(ByteBuffer receivedData) {


        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64536, 4));
    }

    /**
     * 当前检测区域左上角y坐标
     * <p>
     * 在地面的当前检测区域，人的脚在该区域内可以被统计
     * 开始地址 64540
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaLeftTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64540, 4));
    }

    /**
     * 当前检测区域右下角x坐标
     * <p>
     * 在地面的当前检测区域，人的脚在该区域内可以被统计
     * 开始地址 64544
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaRightBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64544, 4));
    }

    /**
     * 当前检测区域右下角y坐标
     * <p>
     * 在地面的当前检测区域，人的脚在该区域内可以被统计
     * 开始地址 64548
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaRightBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64548, 4));
    }

    /**
     * 当前人头检测区域左上角x坐标
     * <p>
     * 人头的检测区域，人的头部在该区域内可以被统计
     * 开始地址 64552
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaLeftTopX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64552, 4));
    }

    /**
     * 当前人头检测区域左上角y坐标
     * <p>
     * 人头的检测区域，人的头部在该区域内可以被统计
     * 开始地址 64556
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaLeftTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64556, 4));
    }

    /**
     * 当前人头检测区域右下角x坐标
     * <p>
     * 人头的检测区域，人的头部在该区域内可以被统计
     * 开始地址 64560
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaRightBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64560, 4));
    }

    /**
     * 当前人头检测区域右下角y坐标
     * <p>
     * 人头的检测区域，人的头部在该区域内可以被统计
     * 开始地址 64564
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaRightBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64564, 4));
    }

    /**
     * 检测线位置
     * <p>
     * 检测线的位置
     * 开始地址 64568
     * 数据长度 4
     */
    public static int getDetectionLinePosition(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64568, 4));
    }

    /**
     * 人头检测线位置
     * <p>
     * 人头检测线的位置
     * 开始地址 64572
     * 数据长度 4
     */
    public static int getHeadDetectionLinePosition(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64572, 4));
    }

    /**
     * 最大检测区域左下角x坐标
     * <p>
     * 补充最大检测区域的左下角和右上角坐标
     * 开始地址 64576
     * 数据长度 4
     */
    public static int getMaxDetectionAreaLeftBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64576, 4));
    }

    /**
     * 最大检测区域左下角y坐标
     * <p>
     * 补充最大检测区域的左下角和右上角坐标
     * 开始地址 64580
     * 数据长度 4
     */
    public static int getMaxDetectionAreaLeftBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64580, 4));
    }

    /**
     * 最大检测区域右上角x坐标
     * <p>
     * 补充最大检测区域的左下角和右上角坐标
     * 开始地址 64584
     * 数据长度 4
     */
    public static int getMaxDetectionAreaRightTopX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64584, 4));
    }

    /**
     * 最大检测区域右上角y坐标
     * <p>
     * 补充最大检测区域的左下角和右上角坐标
     * 开始地址 64588
     * 数据长度 4
     */
    public static int getMaxDetectionAreaRightTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64588, 4));
    }

    /**
     * 当前检测区域左下角x坐标
     * <p>
     * 补充当前检测区域的左下角和右上角坐标
     * 开始地址 64592
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaLeftBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64592, 4));
    }

    /**
     * 当前检测区域左下角y坐标
     * <p>
     * 补充当前检测区域的左下角和右上角坐标
     * 开始地址 64596
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaLeftBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64596, 4));
    }

    /**
     * 当前检测区域右上角x坐标
     * <p>
     * 补充当前检测区域的左下角和右上角坐标
     * 开始地址 64600
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaRightTopX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64600, 4));
    }

    /**
     * 当前检测区域右上角y坐标
     * <p>
     * 补充当前检测区域的左下角和右上角坐标
     * 开始地址 64604
     * 数据长度 4
     */
    public static int getCurrentDetectionAreaRightTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64604, 4));
    }

    /**
     * 当前人头检测区域左下角x坐标
     *
     * @return 十六进制的 String
     * 补充当前人头检测区域的左下角和右上角坐标
     * 开始地址 64608
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaLeftBottomX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64508, 4));
    }

    /**
     * 当前人头检测区域左下角y坐标
     *
     * @return 十六进制的 String
     * 补充当前人头检测区域的左下角和右上角坐标
     * 开始地址 64612
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaLeftBottomY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64612, 4));
    }

    /**
     * 当前人头检测区域右上角x坐标
     *
     * @return 十六进制的 String
     * 补充当前人头检测区域的左下角和右上角坐标
     * 开始地址 64616
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaRightTopX(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64616, 4));
    }

    /**
     * 当前人头检测区域右上角y坐标
     *
     * @return 十六进制的 String
     * 补充当前人头检测区域的左下角和右上角坐标
     * 开始地址 64620
     * 数据长度 4
     */
    public static int getCurrentHeadDetectionAreaRightTopY(ByteBuffer receivedData) {
        return ByteUtils.bytesToInt(ByteUtils.subArray(receivedData.array(), 64620, 4));
    }


    public static String helpMeBaby =
            "                   _ooOoo_" + "\n" +
                    "                  o8888888o" + "\n" +
                    "                  88\" . \"88" + "\n" +
                    "                  (| -_- |)" + "\n" +
                    "                  O\\  =  /O" + "\n" +
                    "               ____/`---'\\____" + "\n" +
                    "             .'  \\\\|     |//  `." + "\n" +
                    "            /  \\\\|||  :  |||//  \\" + "\n" +
                    "           /  _||||| -:- |||||-  \\" + "\n" +
                    "           |   | \\\\\\  -  /// |   |" + "\n" +
                    "           | \\_|  ''\\---/''  |   |" + "\n" +
                    "           \\  .-\\__  `-`  ___/-. /" + "\n" +
                    "         ___`. .'  /--.--\\  `. . __" + "\n" +
                    "      .\"\" '<  `.___\\_<|>_/___.'  >'\"\"." + "\n" +
                    "     | | :  `- \\`.;`\\ _ /`;.`/ - ` : | |" + "\n" +
                    "     \\  \\ `-.   \\_ __\\ /__ _/   .-` /  /" + "\n" +
                    "======`-.____`-.___\\_____/___.-`____.-'======" + "\n" +
                    "                   `=---='" + "\n" +
                    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" + "\n" +
                    "                 佛祖保佑       永不宕机"
                    + "\n"
                    + "一秒后开始执行";
}

